package lambda.functioninterface;


import java.util.function.Supplier;

interface A{
    String get();
}

interface B{
//    String get();
    Integer cau();
}

interface C{
    //只有方法中有参数，使用lambda是才可以传参数进括号
    Integer cau(Integer n);
}

/**
 * @author zhangpeipei
 */
public class FunctionInterface1 {

    /**
     * 这个方法，没有显式的实现接口，
     * 是当接口只有一个方法时，可以直接传进参数列表中这么做吗？
     *
     *
     */
    private static String getString(Supplier<String> stringSupplier) {
        return stringSupplier.get();
    }

    /**
     * 获取一个泛型参数指定类型的对象数据
     * @param integerSupplier 方法的参数为Supplier，泛型使用Integer，一个接口作为参数类型
     * @return 指定类型的对象数据
     */
    public static Integer arrayMax(Supplier<Integer> integerSupplier) {
        return integerSupplier.get();
    }

    public static String interfaceParam(A str){
        return str.get();
    }

    /**
     * 接口里有两个方法也可以传进参数列表
     */
    public static Integer interfaceParam2(B b){
        return b.cau();
    }

    //如果没有返回类型呢？
    public static void runnable(Runnable r){
        r.run();
    }

    public static void main(String[] args) {

        String msgA = "Hello ";
        String msgB = "World ";
        System.out.println(
                getString(() -> msgA + msgB)
        );

        System.out.println(
                interfaceParam(()->msgB)
        );

        int s=1;
        System.out.println(
                interfaceParam2(
                        //s+1就是B
                        ()-> s+1
                ));

        int[] numbers = {100, 200, 300, 400, 500, -600, -700, -800, -900, -1000};
        int numberMax = arrayMax(() -> {
                    int max = numbers[0];
                    for (int number : numbers) {
                        if (max < number) {
                            max = number;
                        }
                    }
                    return max;
                }
        );
        System.out.println("数组中的最大值为：" + numberMax);

        //模仿runnable的写法写supplier
        //表示lambda的括号里不能有参数
        Supplier su = ()-> {
            String str="asd";
            return str;
        };
        System.out.println(su.get());

        //如果有两个方法，就不能使用lambda了，上面的接口B还需要测试
        C c1 = (m)->{
            return m+1;
        };
        //使用的时候
        System.out.println(c1.cau(69));
    }
}
